factory.h

Go to the documentation of this file.

// WOLF - Copyright (C) 2020-2026
// Institut de Robòtica i Informàtica Industrial, CSIC-UPC.
// Authors: Joan Solà Ortega (jsola@iri.upc.edu) and
// Joan Vallvé Navarro (jvallve@iri.upc.edu)
// All rights reserved.
//
// This file is part of WOLF: http://www.iri.upc.edu/wolf
// WOLF is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 3
// as published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#pragma once
 
// wolf
#include "core/common/wolf.h"
#include "core/utils/unused.h"
 
// std
#include <string>
#include <map>
#include <list>
#include <iostream>
#include <iomanip>
 
namespace wolf
{
template <class TypeBase, typename... TypeInput>
class Factory
{
  public:
    // example of creator callback (see typedefs below)
    typedef TypeBase (*CreatorCallback)(TypeInput... _input);
 
  private:
    typedef std::map<std::string, CreatorCallback> CallbackMap;
 
  public:
    static bool                   registerCreator(const std::string& _type, CreatorCallback createFn);
    static bool                   unregisterCreator(const std::string& _type);
    static bool                   isCreatorRegistered(const std::string& _type);
    static TypeBase               create(const std::string& _type, TypeInput... _input);
    std::string                   getClass() const;
    static void                   printAddress();
    static void                   printCallbacks();
    static std::list<std::string> getRegisteredKeys();
 
  private:
    CallbackMap callbacks_;
 
    // Singleton ---------------------------------------------------
    // This class is a singleton. The code below guarantees this.
    // See: http://stackoverflow.com/questions/1008019/c-singleton-design-pattern
  private:
    static Factory& get();
 
  public:
    Factory(const Factory&) = delete;
    void operator=(Factory const&) = delete;
 
  private:
    Factory();
    ~Factory();
};
 
template <class TypeBase, typename... TypeInput>
inline Factory<TypeBase, TypeInput...>::Factory()
{
    // std::cout << " Factory constructor  " << this->getClass() << std::endl;
}
 
template <class TypeBase, typename... TypeInput>
inline Factory<TypeBase, TypeInput...>::~Factory()
{
    // std::cout << " Factory destructor  " << this->getClass() << std::endl;}
}
 
template <class TypeBase, typename... TypeInput>
inline bool Factory<TypeBase, TypeInput...>::registerCreator(const std::string& _type, CreatorCallback createFn)
{
    if (get().callbacks_.count(_type) == 1 and get().callbacks_.at(_type) != createFn)
        throw std::runtime_error(get().getClass() + " : For the type \"" + _type +
                                 "\": Trying to register a creator but there is a different creator registered.");
 
    bool reg = get().callbacks_.insert(typename CallbackMap::value_type(_type, createFn)).second;
 
    if (reg) std::cout << std::setw(31) << std::left << get().getClass() << " <-- registered  " << _type << std::endl;
 
    return reg;
}
 
template <class TypeBase, typename... TypeInput>
inline bool Factory<TypeBase, TypeInput...>::unregisterCreator(const std::string& _type)
{
    return get().callbacks_.erase(_type) == 1;
}
 
template <class TypeBase, typename... TypeInput>
inline bool Factory<TypeBase, TypeInput...>::isCreatorRegistered(const std::string& _type)
{
    return get().callbacks_.count(_type) == 1;
}
 
template <class TypeBase, typename... TypeInput>
inline TypeBase Factory<TypeBase, TypeInput...>::create(const std::string& _type, TypeInput... _input)
{
    typename CallbackMap::const_iterator creator_callback_it = get().callbacks_.find(_type);
 
    if (creator_callback_it == get().callbacks_.end())
        // not found
        throw std::runtime_error(get().getClass() + " : Unknown type \"" + _type +
                                 "\". Possibly you tried to use an unregistered creator.");
 
    // Invoke the creation function
    return (creator_callback_it->second)(std::forward<TypeInput>(_input)...);
}
 
template <class TypeBase, typename... TypeInput>
inline Factory<TypeBase, TypeInput...>& Factory<TypeBase, TypeInput...>::get()
{
    static Factory<TypeBase, TypeInput...> instance_;
    return instance_;
}
 
template <class TypeBase, typename... TypeInput>
inline std::string Factory<TypeBase, TypeInput...>::getClass() const
{
    return "Factory<class TypeBase>";
}
 
template <class TypeBase, typename... TypeInput>
inline void Factory<TypeBase, TypeInput...>::printAddress()
{
    std::cout << get().getClass() << " address: " << &get() << std::endl;
}
 
template <class TypeBase, typename... TypeInput>
inline void Factory<TypeBase, TypeInput...>::printCallbacks()
{
    std::cout << get().getClass() << " callbacks size: " << get().callbacks_.size() << std::endl;
    for (auto cb : get().callbacks_)
    {
        std::cout << "\t" << cb.first << std::endl;
    }
}
 
template <class TypeBase, typename... TypeInput>
inline std::list<std::string> Factory<TypeBase, TypeInput...>::getRegisteredKeys()
{
    std::list<std::string> keys;
    for (auto cb : get().callbacks_)
    {
        keys.push_back(cb.first);
    }
    return keys;
}
 
}  // namespace wolf